…rigin

Probing "can a domain contain a negative number?" (IndexDomain.translate makes
one in two lines) exposed that the literal-coordinate rule was only implemented
for zero-origin domains: on domain [-10, 2), integers were already literal
(t[-5] valid, t[-11] rejected with the true bounds) but slice bounds were
interpreted as POSITIONS within the domain (t[0:2] silently selected storage
[-10, -8)), and the new bounds check hard-coded `< 0` instead of `< lo` —
the same ints-vs-slices inconsistency just removed at origin 0, one level down.

Complete the rule uniformly: slice bounds name coordinates, shifted into the
domain's 0-based range (_resolve_slice_literal; an identity for lo == 0, so
every public view is byte-for-byte unchanged) after _check_slice_bounds rejects
bounds below inclusive_min — the any-origin generalization of "negative raises".
Bounds past exclusive_max still clamp (ranges intersect the domain).

Not publicly reachable today: all .lazy lowering re-zeroes domains, now pinned
by test_public_view_domains_are_zero_origin so a future translate-style API
cannot silently invalidate the documented origin-0 behavior. New
TestNegativeOriginDomains covers int/slice literal semantics on [-10, 2).
Index-array paths on non-zero-origin domains remain to be audited when a
translate API is exposed.

Assisted-by: ClaudeCode:claude-opus-4.8

…dialect, translate

Match TensorStore's indexing model exactly, grounded in an executed behavioral
oracle (tensorstore 0.1.84; every rule below verified empirically and ported to
tests/test_transforms/test_tensorstore_parity.py):

- Domain preservation: a step-1 slice keeps its literal coordinates as the new
  domain (a.lazy[2:10] has domain [2,10); v[3] is coordinate 3 = base cell 3;
  v[0] is out of bounds). Nothing re-zeros implicitly.
- Strided-domain rule: origin = trunc(start/step) (toward zero), size =
  ceil((stop-start)/step), coordinate origin+k -> base start + k*step.
- Strict containment: non-empty slice intervals must lie within the domain (no
  clamping, no negative wrapping); empty intervals are valid anywhere; reversed
  bounds are an invalid-interval error, not an empty result.
- One dialect: views use domain coordinates on EVERY path (lazy accessor and
  eager methods alike); the legacy wraparound/boundscheck pre-validation on the
  view branches is removed, as is _normalize_negative_indices (identity arrays
  still take the unchanged NumPy-dialect legacy fast path).
- translate_domain_by/translate_domain_to on IndexTransform, exposed as
  Array.translate_by / Array.translate_to (TensorStore's translate_*): shift a
  domain, or re-zero a view explicitly, preserving which cells are addressed.
- Index-array values are literal domain coordinates; fancy dims keep fresh
  [0, n) zero-origin domains (already matching TensorStore).
- Views are not iterable (TypeError, like TensorStore): the getitem-from-0
  iteration protocol would silently yield nothing on a preserved domain.
- The I/O layer and chunk_projections normalize to zero-origin via
  translate_domain_to at their boundaries, so chunk resolution and buffer
  placement are unchanged; ChunkProjection.array_selection stays positional.

Negative steps (supported by TensorStore) remain rejected for now — the new
resolver's arithmetic already generalizes, enablement is a follow-up.

Tests: oracle-parity module (47 cases incl. negative-origin domains where -1 is
just another index); all lazy/view/composition/error tests rewritten to domain
coordinates; property parity re-zeroes views via translate_to (exercising it on
every example); superseded zero-origin/clamp-era tests removed.

Assisted-by: ClaudeCode:claude-opus-4.8

… semantics

The theory section now teaches the real model: domains are preserved (an index
is a stable name for a cell, not a position), -1 is just another coordinate —
demonstrably valid after translate_by((-10,)) — strict containment replaces
clamping, strided views renumber by trunc-division, and every path on a view
shares one coordinate system (base arrays keep NumPy semantics unchanged).
Adds translate_to/translate_by patterns, eager iter() rejection on views
(made eager — a generator __iter__ deferred the raise to first next()),
and the positional contract of ChunkProjection.array_selection.
All examples remain live (markdown-exec) and were executed end-to-end.

Assisted-by: ClaudeCode:claude-opus-4.8

…arr-developers#358)

roborev flagged mask-on-non-zero-origin-view as reading "wrong" cells, assuming
NumPy positional semantics. Verified against the executed tensorstore 0.1.84
oracle: TensorStore treats mask True-positions as absolute coordinates counted
from 0, origin-blind (a mask is sugar for the coordinate array of its True
positions), so a True at position 3 on a domain-[2,10) view addresses cell 3 —
exactly our behavior; a True below the origin is out of domain (we reject
eagerly where TensorStore defers to read — the documented timing deviation).

The real gap was coverage: nothing pinned this on a translated view, so the
reviewer could not infer intent. Add the oracle-pinning regression test
(read + write + below-origin rejection) and sharpen the docs callout.

Assisted-by: ClaudeCode:claude-opus-4.8

Assisted-by: Codex:GPT-5

Assisted-by: Codex:GPT-5

Assisted-by: Codex:GPT-5

- _LazyIndexAccessor.shape mirrors the wrapped array/view shape
- LazyViewError now also subclasses AttributeError so hasattr/getattr
  probes (e.g. dask.array.from_array) treat guarded grid members as
  absent instead of crashing
- add a dask.array.from_array interop test and an interop-tests
  dependency group wired into the optional hatch matrix

Assisted-by: ClaudeCode:claude-fable-5

Normalize ArrayMap index arrays to the full input rank of their enclosing
transform: an axis the array varies over is full-sized, every other axis is
a singleton. Dependency axes (orthogonal vs vectorized) become derivable from
the shape via _array_map_dependency_axes; input_dimension is retained as a
compatibility shim for not-yet-migrated consumers. Full rank is preserved
through basic indexing, composition, and JSON.

Assisted-by: ClaudeCode:claude-fable-5

Resolve independent (oindex) and correlated (vindex) ArrayMaps by their
dependency axes during chunk intersection instead of assuming >=2 arrays
are correlated or raveling full-rank arrays to 1-D.

- _intersect routes on input_dimension is None (correlated marker):
  orthogonal maps are filtered along their own dependency axis at full
  input rank; correlated maps are jointly masked over the shared
  broadcast block while residual DimensionMap dims are narrowed against
  the chunk bounds and preserved (previously a rank-1 domain was paired
  with untouched DimensionMap outputs, raising ValueError at read time
  for any vindex with >=2 arrays plus a residual slice dim, including
  partial-rank boolean masks).
- The correlated intersection now emits a flat row-major scatter index
  covering (surviving points, residual slice block), and
  sub_transform_to_selections consumes it as the single out-selection.
- _reindex_array applies basic selections only along an ArrayMap's
  dependency axes; selections on singleton (broadcast) axes narrow the
  domain without touching the array's values, fixing basic slicing of
  the non-fancy axis of an oindex view.
- Degenerate length-1 selections (all-singleton shapes) use
  input_dimension as the tie-breaker so they are not misclassified.
- iter_chunk_transforms returns early for empty fancy selections
  instead of crashing on chunk_ids.min().

Assisted-by: ClaudeCode:claude-fable-5

Normalize public selections at the Array boundary: wrap NumPy-style negatives
against the current view's domain (positive indices stay literal domain
coordinates), reject boolean scalar indices, and route basic-slice-then-fancy
composition through the view's transform. Generalizes the coordinate-selection
wrapping from d0abd4b into one helper used by the lazy accessors and the
non-identity view methods; the transform layer stays literal.

Also reject fields= on a non-identity view (NotImplementedError) in all eight
get/set_*_selection methods before any storage access, fixing silent
corruption where the legacy indexer ignored the transform.

Assisted-by: ClaudeCode:claude-fable-5

A boolean mask must exactly match the view domain's shape on the dimensions
it consumes (NumPy parity: 'boolean index did not match indexed array');
under/over-length masks previously truncated silently and a too-high-rank
mask raised ValueError from the transform layer. Validate in
_normalize_public_selection against the current view domain, raising
IndexError before transform construction.

Also pin the pre-existing eager fields= sibling-field corruption with a
strict xfail so the identity fields test documents rather than hides it.

Assisted-by: ClaudeCode:claude-fable-5

Zero-rank correlated reads (e.g. an integer index into a vindex-created
view) collapsed a flat (1,) working buffer with as_scalar, which returns
shape-(1,) data; collapse to 0-d first so the caller gets a true scalar.

The caller-visible `out` contract for vectorized reads is now the broadcast
selection shape rather than a flat buffer: a flat temporary is used
internally and the reshaped result is copied into the supplied buffer.

Efficiency: reshape the freshly-allocated contiguous working buffer as a
view instead of np.array(...)-copying, and drop the now-redundant second
reshape in get_coordinate_selection's transform branch.

Assisted-by: ClaudeCode:claude-fable-5

Property-based differential oracle for the index-transform layer: an
IndexingProgram composes one to three indexing operations (basic prefix,
optional trailing orthogonal/vectorized step) on a small array and checks
five execution recipes (materialize, eager-on-lazy, out=, scalar and array
writes) against a NumPy model applied in lockstep. Deterministic @example
cases pin slice-then-oindex, unequal orthogonal lengths, multidimensional
vindex with out=, a zero-rank result, and an empty result.

Also restores zero-extent coverage lost with the deleted pre-branch tests:
_indexing_array and the lazy-view parity test draw min_side=0 again (mask
mode verified to work on zero-size shapes and now admitted by _eligible),
and assert_read_matches_numpy learns the transform-path out= convention
(broadcast result shape) so lazy-view vindex reads with multidimensional
results are checked correctly.

Assisted-by: ClaudeCode:claude-fable-5

The async surface built legacy indexers from metadata.shape without
consulting a lazy view's index transform, silently reading/writing the
wrong region (getitem/setitem/selection methods, oindex/vindex accessors,
and from_array's copy loop). Guard every such entry point with a new
AsyncArray._require_identity_for_async helper that raises LazyViewError
on non-identity views, and precheck from_array up front so no half-created
target array is left behind. Steer users to the sync surface / .result().

Assisted-by: ClaudeCode:claude-fable-5

…, 0-d pin, ChunkProjection docs

Address five small code-review items on the lazy-indexing branch:
- Convert branch-introduced bare collection truthiness checks to explicit
  len() comparisons (array.py, transforms/transform.py, testing/strategies.py,
  test_properties.py).
- Convert branch-introduced RST-style ``double-backtick`` markup and
  :role:`target` references to plain markdown backticks, since docs render
  via mkdocs/mkdocstrings (transforms/*.py, chunk_partition.py, errors.py,
  array.py).
- Add changes/3906.feature.md documenting the new .lazy accessor and
  chunk_projections.
- Pin the intentional 0-d array iteration behavior change (raises TypeError
  eagerly at iter(), matching numpy, instead of the old silent empty
  sequence-protocol iteration).
- Document zarr.ChunkProjection under docs/api/zarr/array.md, which was
  exported in zarr.__all__ but missing from the API docs.

Assisted-by: ClaudeCode:claude-fable-5

…forms package

Move the TensorStore-style index-transform algebra out of zarr core into a new
numpy-only uv-workspace subpackage packages/zarr-transforms (import name
zarr_transforms), mirroring packages/zarr-metadata. This is a pure move:
behavior is byte-for-byte unchanged and the full suite stays green.

The package depends on numpy + stdlib only and must not import zarr. Two
couplings are broken:

- errors: the canonical BoundsCheckError / VindexInvalidSelectionError class
  definitions now live in zarr_transforms.errors (both still subclass
  IndexError). zarr.errors re-exports the same objects, so
  zarr.errors.BoundsCheckError is zarr_transforms.errors.BoundsCheckError and
  every existing catch site is unaffected.
- chunk grid: chunk_resolution is typed against new structural Protocols
  (ChunkGridLike / DimensionGridLike) in zarr_transforms.grid instead of
  importing zarr's concrete ChunkGrid, which satisfies them structurally.

zarr now declares a runtime dependency on zarr-transforms, resolved to the
in-tree package via a uv workspace source. The package tests are collected by
the root test suite (they exercise chunk resolution against zarr's ChunkGrid, so
they need zarr importable) rather than run in isolation.

The package __init__ promotes the names the zarr integration layer consumes
(iter_chunk_transforms, sub_transform_to_selections, selection_to_transform) to
the public surface alongside the existing exports.

Assisted-by: ClaudeCode:claude-opus-4.8

Assisted-by: ClaudeCode:claude-opus-4.8

The hatch run-coverage / run-coverage-html / run-hypothesis (and
gputest run-coverage) scripts passed --source=src to coverage run, which
excluded the index-transform algebra after its move to
packages/zarr-transforms/src — it was measured before the move. Declare the
measured source trees in [tool.coverage.run] source instead, so every
coverage run invocation measures both src and the workspace package
consistently, and drop the CLI flag from all four scripts.

Assisted-by: ClaudeCode:claude-opus-4.8

…anges

zarr-transforms is a hard runtime dependency of zarr with no CI. Add
`zarr-transforms.yml` (push/PR path-filtered test/ruff/pyright, mirroring
zarr-metadata; the test job runs from the repo root because the transform
tests import zarr) and `zarr-transforms-release.yml` (tag-triggered publish
on `zarr_transforms-v*`). Extend `check_changelogs.yml` to check the
package's changes directory.

Bump the package `requires-python` floor to >=3.12 (consistent with the
repo; nothing tested 3.11) and update its classifiers, ruff target, and
pyright pythonVersion to match. Extend the root hatch `--match v*` comment
to note the `zarr_transforms-v*` tags it also excludes.

Disclose the two deliberate eager-path changes in the 3906 changelog: the
Array repr `domain={...}` suffix and the 0-d iteration TypeError matching
NumPy. Fix a stale comment in array.py that claimed pop_fields yields []
for no fields (it now yields None).

Assisted-by: ClaudeCode:claude-fable-5

Mirrors zarr_metadata's importlib.metadata idiom; the release
workflow's isolated-wheel check imports it.

Assisted-by: ClaudeCode:claude-fable-5

…ansforms

The ArrayMap (fancy) branch of iter_chunk_transforms enumerated the dense
range(min_chunk, max_chunk + 1) bounding box and ran transform.intersect
against every candidate chunk, making sparse fancy/vindex chunk resolution
scale O(n_chunks) instead of O(n_touched). The exact touched chunk ids were
already computed and then discarded in favor of min/max.

Enumerate each fancy dimension's distinct touched chunk ids (np.unique)
instead; the cartesian product then spans only touched-per-dimension
combinations. Constant/Dimension dims keep their contiguous ranges. Semantics
are unchanged: the dense range only ever added empty intersections, which
intersect already skipped.

Sparse vindex (2 far-apart coords) goes from 15.9x slower than eager at 1k
chunks / 65.5x at 4k to ~1.1x at both, flat in grid size. Dense fancy
selections are unchanged.

Assisted-by: ClaudeCode:claude-fable-5